package com.clouddong.exterapi.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.clouddong.exterapi.ProbeConstant;
import com.clouddong.exterapi.dao.ProbeListDaoI;
import com.clouddong.exterapi.dao.ProbeXmlDaoI;
import com.clouddong.exterapi.po.ProbeListTablePo;
import com.clouddong.exterapi.po.ProbeXmlPingListJoinPo;
import com.clouddong.exterapi.service.ProbeClientServiceI;
import com.clouddong.exterapi.vo.ProbeListTableVo;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;

/**
<blockquote>
<h1></h1>
* @author lpr
* @version 1.0.0
* @date [2018年7月17日 下午1:18:00]
*/
@Service(value="probeClientServiceImpl")
public class ProbeClientServiceImpl implements ProbeClientServiceI
{
	@Autowired
	private ProbeXmlDaoI probeXmlDaoI;
	@Autowired
	private ProbeListDaoI probeListDaoI;
	
	// 定义一个存放key为省份，value为List<&JSONObject>类型的地市数据，用来判断省份的Ping码
	private static Map<String, List<Map<String, Object>>> IS_PROPING_JSON = new LinkedHashMap<>();

	/**
	<blockquote>
	<h1>根据传入的List&<&XMLPingListJointPo>对象封装最终返回的JSON,只负责将JSON封装为指定格式</h1>
	* @version 1.0.0
	* @param objList
	* @return
	 */
	@Override
	public Map<String,List<Map<String, Object>>> getFinalJsonIsClient(List<ProbeXmlPingListJoinPo> dataList) throws Exception
	{
		Map<String,List<Map<String, Object>>> retMap=new HashMap<>();//定义最终返回的JSON
		for(int i=0,len=dataList.size();i<len;i++ ){//遍历得到的数据对象
			 ProbeXmlPingListJoinPo p=dataList.get(i);
			    List<Map<String,Object>> objAll=new ArrayList<>();//定义一个Object类型的集合用来当作返回的JSON的value
				String provinceKey=p.getProbe_province();//获取字段中的省份信息
				String cityName=p.getProbe_city();//获取字段中的地市信息
				//获取地市Ping码的实际对应值
				Integer lostRate=p.getLost_rate();
				Integer cityPingCode=isCityPingCodeIsOper(lostRate!=null?Long.valueOf(lostRate):0L,p.getType_id());
				if(retMap.containsKey(provinceKey))
				{//判断JSON中是否已经存在该省份
					//将省份信息写入到JSON中
					objAll.add(getOneProJsonIsClient(p.getProbe_province(),cityPingCode));
					//获得添加地市后的List<JSONObject>类型的数据
					List<Map<String, Object>> cityJson= IS_PROPING_JSON.get(provinceKey);
					//将地市信息写入isProPingJson
					cityJson.add(getOneCityJsonIsClient(cityName,cityPingCode));
					IS_PROPING_JSON.put(provinceKey, cityJson);
				}else {//不存在
					//将省份信息写入到JSON中
					objAll.add(getOneProJsonIsClient(p.getProbe_province(),cityPingCode));
					//将地市信息写入isProPingJson
					List<Map<String, Object> > l= new ArrayList<>();
					l.add(getOneCityJsonIsClient(cityName, cityPingCode));
					IS_PROPING_JSON.put(provinceKey, l);
				}
				retMap.put(provinceKey, objAll);//添加数据
			}
		return retMap;
	}
	
	/**
	<blockquote>
	<h1>从数据库获取数据</h1>
	* @version 1.0.0
	* @param task_id
	* @return
	 */
	@Override
	@Transactional(readOnly=true,propagation=Propagation.REQUIRED)
	public List<ProbeXmlPingListJoinPo> getDataSourceIsClientPingMap(String taskId)
	{
		HashMap<String, Object> map=new HashMap<>();
		map.put("task_id", taskId);
		//获取到最终的结果集,里面封装了的到的所有省份，地市，地市对应的Ping码
		List<ProbeXmlPingListJoinPo> xmlList =probeXmlDaoI.getUnionDataToXmlPingList(map);//根据传入的task_id获取到对应的ProbeXmlVo集合
		return xmlList;
	}
	/**
	 <blockquote>
	 <h1>以分页的方式从数据库获取数据</h1>
	 * @param task_id
	 * @param pageNum - 当前页
	* @param pageSize - 每页几条数据
	 * @return
	 */
	@Override
	@Transactional(readOnly=true,propagation=Propagation.REQUIRED)
	public PageInfo<ProbeXmlPingListJoinPo> getPageDataSourceIsClientPingMap(String taskId,Integer pageNum,Integer pageSize)
	{
		HashMap<String, Object> map=new HashMap<>();
		map.put("task_id", taskId);
		PageHelper.startPage(pageNum,pageSize);
		//获取到最终的结果集,里面封装了的到的所有省份，地市，地市对应的Ping码
		List<ProbeXmlPingListJoinPo> dataList =probeXmlDaoI.getUnionDataToXmlPingList(map);//根据传入的task_id获取到对应的ProbeXmlVo集合
		PageInfo<ProbeXmlPingListJoinPo> pageInfo=new PageInfo<>(dataList);
		return pageInfo;
	}
	/**
	<blockquote>
	<h1>获取关于运维的查询功能数据源</h1>
	* @version 1.0.0
	* @param proListTableVo
	* @return
	 */
	@Override
	@Transactional(readOnly=true,propagation=Propagation.REQUIRED)
	public List<ProbeListTablePo> getDataSourceIsOperQuery(ProbeListTableVo proListTableVo)
	{
		HashMap<String, Object> map=new HashMap<>();//定义存放SQL所需数据的MAP
		map.put("proListTableVo", proListTableVo);
		List<ProbeListTablePo> poList=probeListDaoI.getProbeListByIdCityIsLink(map);
		return poList;
	}
	/**
	<blockquote>
	<h1>封装省份返回的JSON</h1>
	* @version 1.0.0
	* @param key - JSON的key
	* @param value - JSON的value
	* @return - 封装后的JSON
	 */
	private Map<String, Object> getOneProJsonIsClient(String key,Integer value)
	{
		Map<String, Object> retMap=new HashMap<>();//定义一个JSON临时变量,用来存放省份及其对应状态
		retMap.put(PRO_PINGNAME_KEY, key);
		retMap.put(PRO_PINGCODE_KEY, value);
		return retMap;
	}
	/**
	<blockquote>
	<h1>封装最终返回的分页用的JSON</h1>
	* @param draw - 页面发送的draw
	* @param recordsTotal - 总记录数
	* @param recordsFiltered - 过滤后的记录数
	* @param data
	* @return
	 */
	public static Map<String, Object> getFinalPageDataJson(Integer draw, Long recordsTotal,Long recordsFiltered,Object data)
	{
		Map<String, Object> retMap=new LinkedHashMap<>();
		retMap.put("draw",draw==null?0:Integer.parseInt(draw.toString()));//页面发送的draw， 为了防止跨站脚本（XSS）攻击
		retMap.put("recordsTotal", recordsTotal);//总记录数
		retMap.put("recordsFiltered", recordsFiltered);//过滤后的记录数
		retMap.put("data", data);//数据
		return retMap;
	}
	
	/**
	<blockquote>
	<h1>根据typeId判断地市Ping码对应的汉字表达</h1>
	* @param typeId - 下发类型 
	* @param cityPingCode - 地市Ping码
	* @return
	 */
	public static String isCityCodeOutVal(String typeId,Integer cityPingCode)
	{
		String retMap="不通";
		if("0".equals(typeId))
		{//判断是否为封堵
			if(new Integer(0).equals(cityPingCode)){retMap="通";}	
			if(new Integer(1).equals(cityPingCode)){retMap="不通";}	
		}
		if(ProbeConstant.TYPE_ID_PING.equals(typeId))
		{//判断是否为Ping
			
			if(new Integer(0).equals(cityPingCode)){retMap="通";}	
			if(new Integer(1).equals(cityPingCode)){retMap="不通";}	
		}
		return retMap;
		
	}
	/**
	<blockquote>
	<h1>根据type_id判断地市Ping码对应的返回值</h1>
	* @version 1.0.0
	* @param cityPingCode
	* @param type_id
	* @return 判断后的值，如果无匹配的type_id则返回cityPingCode的Int形式
	* @throws ClassCastException
	 */
	public static Integer isCityPingCodeIsOper(Long cityPingCode,String typeId) throws ClassCastException
	{
		Integer retLong=0;
		if("0".equals(typeId))
		{//判断是否为封堵
			if (cityPingCode != null && cityPingCode.equals(100000L))
			{
				retLong = 0;//通
			}
			if (cityPingCode != null && cityPingCode.longValue() < 100000L)
			{
				retLong = 1;//不通
			}
		}
		if(ProbeConstant.TYPE_ID_PING.equals(typeId)||
				ProbeConstant.TYPE_ID_TRACE.equals(typeId)
				)
		{//判断是否为Ping和TRACE
			if (cityPingCode != null && cityPingCode.equals(100000L))
			{
				retLong = 1;//不通
			}
			if (cityPingCode != null && cityPingCode.longValue() < 100000L)
			{
				retLong = 0;//通
			}
		}
		if (ProbeConstant.TYPE_ID_DNS.equals(typeId))
		{//判断是否为DNS
			if (cityPingCode != null && cityPingCode.longValue() < 100000L)
			{
				retLong = 1;//通
			}
			if (cityPingCode != null && cityPingCode.equals(0L))
			{
				retLong = 0;//不通
			}
		}
		return retLong;
	}
	/**
	<blockquote>
	<h1>封装地市返回的JSON</h1>
	* @version 1.0.0
	* @return
	 */
	private Map<String, Object> getOneCityJsonIsClient(String key,Integer value)
	{
		
		Map<String, Object> retMap=new HashMap<>();//定义一个JSON临时变量,用来存放地市及其对应状态
		retMap.put(CITY_PINGNAME_KEY, key);
		retMap.put(CITY_PINGCODE_KEY, value);
		return retMap;
	}
	
	public static Map<String, List<Map<String, Object>>> getIsProPingJson()
	{
		return IS_PROPING_JSON;
	}

}
